#ifndef NODO_H_
#define NODO_H_
#include "Tipos.h"
#include "NodoBase.h"

template<class CClave>
class CNodo : public CNodoBase<CClave>
{
public:
	TIPO_DATO	sucesorIzq;	
	TIPO_DATO	m_sucDerAux;
	// FIN	
	VectorClavesNodo  clave;	 //vamos a usar template de vectores
	//string				m_dato;
	CNodo();
	CNodo(CNodo &nodo);
	CNodo(CNodoBase<CClave> &nodo);
	CNodo(TIPO_DATO nivel , TIPO_DATO nroBloque);
	~CNodo();	
   	void setClave(CClaveNodo<CClave> *clave){this->clave[this->cantRegistro-1]=(clave); this->posicion = this->cantRegistro-1;}   		
   	void setClave(CClaveNodo<CClave> &clave){this->clave[this->cantRegistro-1]=(&clave);this->posicion = this->cantRegistro-1;}   	
   	void setClave(CClaveNodo<CClave> &clave, TIPO_DATO posicion){this->clave[posicion]=(&clave);}   	
   	void setClave(CClave &clave, TIPO_DATO posicion){
		CClaveNodo<CClave> *nodo= new CClaveNodo<CClave>;
		TIPO_DATO suc;
		suc = ((CClaveNodo<CClave>*)this->clave[posicion])->getSucesorDer();
		nodo->setClave(clave);
		nodo->setSucesor(suc);
		this->clave[posicion] = nodo;};
   	void setClave(CClave &clave){
		CClaveNodo<CClave> *nodo= new CClaveNodo<CClave>;
		TIPO_DATO suc;
		if(this->cantRegistro==1)
			suc = this->m_sucDerAux;
		else
			suc = ((CClaveNodo<CClave>*)this->clave[this->cantRegistro-1])->getSucesorDer();
		nodo->setSucesor(suc);
		nodo->setClave(clave);
		this->clave[this->cantRegistro-1] = nodo;};

	void setSucesorIzq(TIPO_DATO suc){sucesorIzq = suc;}
  	void setSucesorDer(TIPO_DATO suc,TIPO_DATO indice){((CClaveNodo<CClave>*)clave[indice])->setSucesor(suc);}	
	void setSucesorDer(TIPO_DATO suc){((CClaveNodo<CClave>*)clave[this->cantRegistro-1])->setSucesor(suc);}	
	void setSigSetSec(TIPO_DATO blqSig){}/*B+*/
 	   	
 	void clear(){this->clave.clear();}
	void distribuirClaves( TIPO_DATO &sucesorIzq, TIPO_DATO &sucesorDer,CClave &clave,CNodo<CClave> &nodoNuevo);
	void redistribuirRaiz(CClave &clave,TIPO_DATO nroBloqueViejo,TIPO_DATO nroBloqueNuevo,CNodoBase<CClave> &nodoNuevo);	
	void fusionar(CNodoBase<CClave> &nodoPadre,TIPO_DATO posPadre,CNodoBase<CClave> &nodoHrno);
	void procesarNodo(TIPO_DATO indice);
	bool equilibrarConHrno(TIPO_DATO indice);
	void eliminar(TIPO_DATO indice);
    void insertarOrdenado(CClave& clave,TIPO_DATO nroBloqueViejo,TIPO_DATO nroBloqueNuevo);
//	void trasformar(char dato[TAMANIO_NODO],int posicion){};
	void transformar(string datos);
	string desTransformar();

//	TIPO_DATO getCantRegistros();/**TODO */	
	bool obtenerNroBloque(CClave &espacioLibre,TIPO_DATO &nroBloqueOut,fstream &archivo);
		TIPO_DATO getSucesorIzq(){return sucesorIzq;}
	TIPO_DATO getSucesorDer(int indice);
	CClaveNodo<CClave> &getClaveNodo(TIPO_DATO indice){return *((CClaveNodo<CClave>*)clave[indice]);}	
	CClaveNodo<CClave>* getspClaveNodo(TIPO_DATO indice){return (CClaveNodo<CClave>*)clave[indice];}		
	CClave* getspClave(TIPO_DATO indice){return &((CClaveNodo<CClave>*)clave[indice])->clave;}
 	CClave& getClave(TIPO_DATO indice){return ((CClaveNodo<CClave>*)clave[indice])->clave;}
 	TIPO_DATO getTamRegistro(TIPO_DATO indice){return ((CClave*)clave[indice])->getTamanio();}
	TIPO_DATO getTamanio();
	TIPO_DATO getTamanio(int indice);
	TIPO_DATO getSigSetSec(void){return 0;} /*B+*/
	void mostrar();
	bool hayLugar(CClave &claveIn){return (this->espacioLibre >= (claveIn.getTamanioNodo()+ TAMANIO_SUC_DER));}
	/*ordeno el mapa que tiene la clase que lo usa.*/
	void ordenar();
	void insertarVectorSec(CClave &clave,fstream &archivo);
	bool cambiarClave(CClave &claveVieja,CClave &claveNueva);
	bool eliminarElemVector(TIPO_DATO claveIn,fstream &archivo);
	bool puedoFusionar(TIPO_DATO tamHermano,TIPO_DATO tamClave);
	void intercambiar(CNodoBase<CClave> &nodoHrno,bool hrnoDerecho,CNodoBase<CClave> &nodoPadre,TIPO_DATO posPadre);

};
/*-----------------------------------------------------------*/
template<class CClave>
CNodo<CClave>::CNodo()
{}
/*-----------------------------------------------------------*/
template<class CClave>
CNodo<CClave>::CNodo(CNodo<CClave> &nodo)
{
	TIPO_DATO cantReg;
	CClaveNodo<CClave> * nodoAux;
	cantReg = nodo.getCantRegistros();
	this->espacioLibre = nodo.getEspacioLibre();
	for(TIPO_DATO i=0;i<cantReg;i++)
	{
		nodoAux = new CClaveNodo<CClave>;
		nodoAux = nodo.getspClaveNodo(i);
		nodo.setClave(*nodoAux);
	}
}
/*-----------------------------------------------------------*/
template<class CClave>
CNodo<CClave>::CNodo(CNodoBase<CClave> &nodo)
{
	TIPO_DATO cantReg;
	CClaveNodo<CClave> *nodoAux;
	cantReg = nodo.getCantRegistros();
	this->espacioLibre = nodo.getEspacioLibre();
	for(TIPO_DATO i=0;i<cantReg;i++)
	{
		nodoAux = new CClaveNodo<CClave>;
		nodoAux = ((CNodo<CClave>)nodo).getspClaveNodo(i);
		this->setClave(*nodoAux);
	}
}
/*-----------------------------------------------------------*/
template<class CClave>
CNodo<CClave>::CNodo(TIPO_DATO nivel, TIPO_DATO nroBloque)
{
	this->nivel =nivel ;
	this->nroNodoBloque = nroBloque;
	m_sucDerAux = 0;
}
template <class CClave >
CNodo<CClave>::~CNodo()
{
	itVectorClavesNodo it;	
	for(it = this->clave.begin();it != this->clave.end();it++)
	{
		delete((CClaveNodo<CClave>*)(*it).second);
		
	//	clave.erase(it);
	}
	clave.clear();
	
}
/*-----------------------------------------------------------*/
template <class CClave >
void CNodo<CClave>::eliminar(TIPO_DATO indice)
{
//	TIPO_DATO index=0;
//	bool encontrada=false;
	itVectorClavesNodo it;

	it = this->clave.find(indice);
	if(it!=clave.end())
	{
		TIPO_DATO i;
		if(this->cantRegistro==1)
			this->m_sucDerAux = ((CClaveNodo<CClave>*)this->clave[(*it).first])->getSucesorDer();
		this->espacioLibre += ((CClaveNodo<CClave>*)((*it).second))->getTamanio();
		this->clave.erase(it);
		this->cantRegistro--;
		for(i=indice;i<this->cantRegistro;i++)
			clave[i]=clave[i+1];
		this->clave.erase(i);
	}
	

/*
	it = this->clave.begin();
	while((it != this->clave.end()) && !encontrada)
	{
		if(index==indice)//(clave==(*it))
		{
			encontrada=true;
			this->clave.erase(it);
			this->cantRegistro--;
		}		
		++it;
		++index;
	}
	*/
}
/*-----------------------------------------------------------*/
template <class CClave >
void CNodo<CClave>::insertarOrdenado(CClave& key,TIPO_DATO nroBloqueViejo,TIPO_DATO nroBloqueNuevo)
{
	CClaveNodo<CClave> *claveAux;
	CClaveNodo<CClave> *claveNodo;
    TIPO_DATO i=0;

	//clave que entra
	claveNodo = new CClaveNodo<CClave>;	
	claveNodo->setClave(key);
	claveNodo->setSucesor(nroBloqueNuevo);	

	i = this->cantRegistro;
	while( (i > 0) && (key < ((claveAux = this->getspClaveNodo(i-1)))->clave) )
	{//corro las mayores un lugar a la derecha			
		this->setClave(*claveAux,i); 
		--i;		
	}
/*ARIEL*/
//	this->setClave((*claveNodo).clave,i); 	
	this->setClave(*claveNodo,i); 	
/**/
	this->posicion =i;
	this->espacioLibre -= claveNodo->getTamanio();
	//incremento la cantidad de registros
	this->setCantRegistros(this->getCantRegistros()+1);
	
	//verifico si entro en el primer registro
	unsigned long derCero=0;
	unsigned long nuevo=0;
	derCero = this->getSucesorDer(0);
	nuevo = nroBloqueNuevo;
	cout<<"---"<<endl;
	if(derCero == nuevo)
	{
		cout<<"Es igual"<<endl;
	}
	if(derCero < nuevo)
	{
		cout<<"Es menor"<<endl;
	}
	if(derCero == nuevo)
	{
		cout<<"Es igual"<<endl;
	}
	if(derCero > nuevo)
	{
		cout<<"Es mayor"<<endl;
	}
	if(derCero == nuevo)
	{
		cout<<"Es igual"<<endl;
	}
	cout<<"---"<<endl;
 	if( (unsigned long)(this->getSucesorDer(0)) == (unsigned long)nroBloqueNuevo )
 	{//se trata de la clave que se paso por parametro
 		this->sucesorIzq = nroBloqueViejo; 
 		cout<<"Modifique el suc"<<endl;	
 	} 
 	
}
/*-----------------------------------------------------------*/
/*informa si puedo sacar un registro de este nodo sin que quede en underflow*/
template<class CClave>
bool CNodo<CClave>::equilibrarConHrno(TIPO_DATO indice)
{
	TIPO_DATO  tamRegByte;
	TIPO_DATO  porcentaje;
	//tengo el tamanio del ultimo registro
	tamRegByte = this->getTamRegistro(indice);
	porcentaje = (TIPO_DATO)(((double)(this->espacioLibre + tamRegByte )/TAMANIO_NODO)*100);
	if(porcentaje > PORCENTAJE_MINIMO)
		return false;
	return true;	
}
/*-----------------------------------------------------------*/
/*
	posNodoviejo: Item de la rama nueva
	posNodoNuevo: Item de la rama Vieja
*/
template <class CClave >
void CNodo<CClave>::distribuirClaves(TIPO_DATO &sucIzq, TIPO_DATO &sucDer,CClave &key,CNodo<CClave> &nodoNuevo)
{
     /* metodo para NODO */
     //creo un superNodo conteniendo el nodo viejo mas la clave nueva insertada
     //en el lugar correcto
     VectorClavesNodo	SuperNodo;
     CClaveNodo<CClave> *claveNodo,*claveNodoPromuevo;
//     CClaveNodo<CClave> *
     TIPO_DATO corte, cantRegSuperNodo=0;

     TIPO_DATO i=0;
	CClaveNodo<CClave> *claveAux;
	CClave	*promociona;
	 promociona = new CClave;
     /**/
     
 /****************SUPER NODO !!!!!!!!!!!!!***************************/
/****************SUPER NODO !!!!!!!!!!!!!***************************/     
//     claveAux =this->getspClaveNodo(0);
	/*Inserta la nueva clave en un supernodo de forma ordenada*/
	for(i=0; (i<this->cantRegistro) && (this->getspClaveNodo(i)->clave) < key ; i++)
		SuperNodo[i]=this->getspClaveNodo(i);
	
	*promociona = key;
	//clave que entra
	claveNodo = new CClaveNodo<CClave>;	
	claveNodo->setClave(*promociona);
	claveNodo->setSucesor(sucDer);
	
	SuperNodo[i]=claveNodo;

//	if(i==0)
//		++i;

	for(; i<this->cantRegistro; i++)
	{
		claveAux = this->getspClaveNodo(i);
		SuperNodo[i+1]=(claveAux);
	}

     //aca el super nodo contine todas las claves ordenadas
     //ahora armo los nodos viejo y nuevo obteniendo la clave a promocionar
     cantRegSuperNodo = ++i;
     
	cout<<"Contenido del supernodo al insertar. Distribuir clave NODO "<<endl;

//    for(int h=0; h<(int)cantRegSuperNodo ; h++)
//		((CClaveNodo<CClave>*)SuperNodo[h])->mostrar(); 

/**************** FIN SUPER NODO !!!!!!!!!!!!!***************************/
/**************** FIN SUPER NODO !!!!!!!!!!!!!***************************/
     

     corte = (i/2);
     TIPO_DATO j;
     
     this->clear();
     for(j=0; j<corte; j++ )     
	 	this->setClave(*((CClaveNodo<CClave>*)SuperNodo[j]),j); //cargo las claves al nodo viejo
	
      //SETEAR LA CANTIDAD DE REGISTROS
  	 this->cantRegistro = j;
  	 
  	 cout<<"Contenido del nodo (IZQ) luego de distribuir el supernodo"<<endl;
//	 for(int h=0; h<(int)this->cantRegistro; h++ )     
//	 	this->getClave(h).mostrar();
  	   	 
     //esta clave es la que promociona
     claveNodoPromuevo = ((CClaveNodo<CClave>*)SuperNodo[j++]);
     
     key = claveNodoPromuevo->clave;
   //  delete  ((CClave*)&(claveNodoPromuevo->clave));
   //esto es si la que promuevo es la misma que se va.....
  	nodoNuevo.setSucesorIzq(claveNodoPromuevo->sucesorDer);
     for(; j<(cantRegSuperNodo); j++)     
	 	nodoNuevo.setClave(*((CClaveNodo<CClave>*)SuperNodo[j]),j-corte-1);
     
      //SETEAR LA CANTIDAD DE REGISTROS           
 	 nodoNuevo.setCantRegistros(j-corte-1); 	
 	 delete  ((CClave*)&(claveNodoPromuevo->clave));
 	
	cout<<"Contenido del nodo (DER) luego de distribuir el supernodo"<<endl;
//	for(int h=0; h<(int)(j-corte-1); h++)
//		nodoNuevo.getClave(h).mostrar();
		
 	//ahora voy a ver si la clave que se agrego se inserto en el primer registro del
 	//nuevo nodo o en uno del medio
 	if(nodoNuevo.getSucesorDer(0) == sucDer )
 	//se trata de la clave que se paso por parametro
 		nodoNuevo.setSucesorIzq(sucIzq);
	//verifico si entro en el primer registro del nodo viejo
 	if(this->getSucesorDer(0)== sucDer )
 	//se trata de la clave que se paso por parametro
 		this->sucesorIzq = sucIzq; 		
 	
 	//informo cual va a ser los nuevos sucesores derechos e izquierdos de la clave promovida
 	//este nodo es el bloque viejo osea sucesor Izq
  	 sucIzq = this->nroNodoBloque;
  	 //este nodo es el bloque Nuevo osea sucesor Der
     sucDer = nodoNuevo.getNroBloque(); 	
}
/*-----------------------------------------------------------*/
//this: es el ultimo elemento de la rama, es la nueva raiz
template <class CClave >
void CNodo<CClave>::redistribuirRaiz(CClave &clave,TIPO_DATO nroBloqueViejo,TIPO_DATO nroBloqueHrnoViejo,CNodoBase<CClave> &raizAntigua)
{	
	TIPO_DATO nroBloqAux; //intercambio el nro de bloques
	nroBloqAux = raizAntigua.getNroBloque();
	raizAntigua.setNroBloque( this->getNroBloque() );
	this->setNroBloque(nroBloqAux);//este numero de bloque tendria que ser cero por ser la raiz
	
	this->setSucesorIzq(raizAntigua.getNroBloque());//seteo el hijo izq del nodo raiz

//	CClaveNodo<CClave> claveAux;
//	claveAux.clave = clave;
//	claveAux.sucesorDer = nroBloqueNuevo;
//	this->setCantRegistros(1); //la raiz solo tendra la clave promovida	
//	this->setClave(claveAux);		
/*ARIEL*/
	CClaveNodo<CClave> *claveNodo; //clave que entra	
	claveNodo = new CClaveNodo<CClave>;	
	claveNodo->setClave(clave);
	claveNodo->setSucesor(nroBloqueHrnoViejo);

	this->setCantRegistros(1); 	//la raiz solo tendra la clave promovida	
	this->setClave(*claveNodo,0);//es la primer clave de la raiz
/**/	
}
/*-----------------------------------------------------------*/
template <class CClave >
void CNodo<CClave>::transformar(string datos)
{
	TIPO_DATO posicion = 0;
	TIPO_DATO tamanioDatos=0;//este es el tama�o de datos en byte que se esta acumulando.
	 	
 //	TIPO_DATO pos = this->m_posicionTrans+1;

	CNodoBase<CClave>::transformar(datos,posicion);
	this->sucesorIzq = string2TipoDato(datos.substr(posicion,TAMANIO_SUC_IZQ));
	posicion+=TAMANIO_SUC_IZQ;
	this->espacioLibre -=TAMANIO_SUC_IZQ;
	//transformar los datos en clave
	 for(TIPO_DATO i=0; i<this->cantRegistro; i++)
	 	 {
	 	 	CClaveNodo<CClave> *claveNodo =new CClaveNodo<CClave> ;	 	 	
//	 	 	CClaveNodo<CClave> cn;
	 	 	//Parseo la clave
			tamanioDatos += claveNodo->transformar(datos, posicion);
			//claveNodo->clave.trasformar(datos, pos);
//	 	 	pos = cn.clave.trasformar(datos, pos);
			//claveNodo->sucesorDer = datos[pos];
			//cn.sucesorDer = datos[pos];
			//pos++;
//			cout<<"NUMERO DEL NODO"<<i<<endl;
			if(i==84)
				cout<<endl;
	 	 	this->clave[i]=(claveNodo);
		 }
	this->espacioLibre -=tamanioDatos ;
}
/*-----------------------------------------------------------*/
template <class CClave >
void CNodo<CClave>::mostrar() /* = std::cout*/
{
	itVectorClavesNodo it;
	cout<<endl<<"\tNumero de bloque Indice: "<<this->nroNodoBloque<<endl;
	cout<<" Nivel del nodo : "<<this->nivel<<endl;
	cout<<"Sucesor Izquierdo : "<<this->sucesorIzq<<endl;
	for(it=clave.begin();it!=clave.end();it++)
		((CClaveNodo<CClave>*)(*it).second)->mostrar();
}
/*-----------------------------------------------------------*/
template<class CClave>
string CNodo<CClave>::desTransformar()
{
//	char numero[10];
	string dato="";
	//m_dato="";
	CClaveNodo<CClave> claveNodoAux;
	itVectorClavesNodo it;
	dato+= CNodoBase<CClave>::desTransformar();
	//dato += itoa(sucesorIzq,numero,10);	
	dato+= convertirChar(sucesorIzq,TAMANIO_SUC_IZQ);	
	for(it=clave.begin();it!=clave.end();it++)
	//for(TIPO_DATO i=0; i<this->cantRegistro; i++)
	 {
		 claveNodoAux = getClaveNodo((*it).first);
		 dato+=claveNodoAux.desTransformar();
	 }
	return dato;     
}
/*-----------------------------------------------------------*/
template <class CClave >
void CNodo<CClave>::fusionar(CNodoBase<CClave> &nodoPadre,TIPO_DATO posPadre,CNodoBase<CClave> &nodoHrno)
{
	TIPO_DATO cantReg;
	TIPO_DATO sucDerPadre,sucIzqHrno;
	CClaveNodo<CClave> *spClaveAux=NULL;
	TIPO_DATO i=0;
	/*pasamos el vector del hermano al vector this*/
	cantReg = nodoHrno.getCantRegistros();
	while(i<cantReg)
	{
		spClaveAux = new CClaveNodo<CClave>;
		spClaveAux = nodoHrno.getspClaveNodo(i++);
/*jny*/	this->espacioLibre -= spClaveAux->getTamanio();
		this->cantRegistro++;
		this->setClave(*spClaveAux);
	}
	sucIzqHrno = nodoHrno.getSucesorIzq();
	/*TODO MANEJAR EL ARCHIVO DE ESPACIOS LIBRES*/
	nodoHrno.clear();//borramos el nodo hermano
	spClaveAux = nodoPadre.getspClaveNodo(posPadre);
	sucDerPadre = nodoPadre.getSucesorDer(posPadre);
	spClaveAux->sucesorDer = sucIzqHrno;
	/*jny*/this->espacioLibre -=spClaveAux->getTamanio();
	this->cantRegistro++;
	this->setClave(spClaveAux);
	ordenar();	
/*TODO*///	sort(clave.begin(),clave.end());
	/*ACTUALIZO EL NODO PADRE*/
	if(this->nroNodoBloque==sucDerPadre)	
		if(posPadre==0)		
			nodoPadre.setSucesorIzq(nodoHrno.getNroBloque());		
			//nodoPadre.setSucesorIzq(this->nroNodoBloque);		
		else		
			nodoPadre.setSucesorDer(posPadre-1,this->nroNodoBloque);
	nodoPadre.eliminar(posPadre);
	if(nodoPadre.getCantRegistros()==0 && (nodoPadre.getSucesorIzq()!=this->nroNodoBloque))
		nodoPadre.setSucesorIzq(-1);
}
/*-----------------------------------------------------------*/
template <class CClave >
void CNodo<CClave>::procesarNodo(TIPO_DATO indice)
{	
	this->getClave(indice)->mostrar();		
	/*TODO ver que proceso se le da a esta clave*/
}
/*-----------------------------------------------------------*/
template<class CClave>
TIPO_DATO CNodo<CClave>::getSucesorDer(int indice)
{
	return ((CClaveNodo<CClave>*)clave[indice])->sucesorDer;
}
template<class CClave>
void CNodo<CClave>::ordenar()
{
	int						posicion=0;
	VectorClavesNodo		vectorClaves;
	itVectorClavesNodo		it;
	for(it=clave.begin();it!=clave.end();it++)
		((CClave*)((*it).second))->mostrar();

	for(it=clave.begin();it!=clave.end();it++,posicion++)
	{
		int cont=posicion;
		//vectorClaves.insert(*it);
		while((posicion!=0) && cont>0 &&(*((CClave*)((*it).second)))<(*((CClave*)vectorClaves[cont-1])))
		{
			vectorClaves[cont] = vectorClaves[cont-1];
			--cont;
		}
		vectorClaves[cont]=(*it).second;
	}
	clave.clear();	
	for(it=vectorClaves.begin();it!=vectorClaves.end();it++)
		clave.insert((*it));
	vectorClaves.clear();
	/*mustro como quedo*/
	for(it=clave.begin();it!=clave.end();it++)
		((CClave*)((*it).second))->mostrar();

}
template<class CClave>
void CNodo<CClave>::insertarVectorSec(CClave &claveIn,fstream &archivo)
{
	((CClaveNodo<CClave>*)this->clave[this->posicion])->insertarVectorSec(claveIn,archivo);
	//((CClaveNodo<CClave>*)clave[posicion])
}
template <class CClave >
bool CNodo<CClave>::cambiarClave(CClave &claveVieja,CClave &claveNueva)
{
	return ((CClaveNodo<CClave>*)this->clave[this->posicion])->cambiarClave(claveVieja,claveNueva);	
}

template<class CClave>
bool CNodo<CClave>::obtenerNroBloque(CClave &espacioLibre,TIPO_DATO &nroBloqueOut,fstream &archivo)
{
	bool encontrado =false;
	TIPO_DATO i;
	for( i=0;i<this->cantRegistro && !encontrado;i++)
	{
		if((((CClaveNodo<CClave>*)(this->clave[i]))->getClave())==espacioLibre)
			encontrado =true;
	}
	if(encontrado)
		encontrado=((CClaveNodo<CClave>*)this->clave[i-1])->obtenerNroBloque(nroBloqueOut,archivo);
	else
		cout<<"Tendria que haberlo encontrado"<<endl;
	return encontrado;
}
template<class CClave>
bool CNodo<CClave>::eliminarElemVector(TIPO_DATO claveIn,fstream &archivo)
{
	bool eliminado;
	this->m_eliminar=false;
	eliminado = ((CClaveNodo<CClave>*)this->clave[this->posicion])->eliminarElemVector(claveIn,archivo);
	if(((CClaveNodo<CClave>*)this->clave[this->posicion])->getIndice()==0)
		this->m_eliminar=true;
		//this->eliminar(this->posicion);
	return eliminado;
	//return ((CClaveNodo<CClave>*)this->clave[this->posicion])->eliminarElemVector(claveIn,archivo);
}
template<class CClave>
TIPO_DATO CNodo<CClave>::getTamanio()
{
	TIPO_DATO tamanio=0;
	itVectorClavesNodo it;
	tamanio = TAMANIO_CANTIDAD_REGISTRO +TAMANIO_NIVEL;
	for(it=this->clave.begin();it!=this->clave.end();it++)
		tamanio+=((CClaveNodo<CClave>*)((*it).second))->getTamanio();
	return tamanio;
}
template<class CClave>
TIPO_DATO CNodo<CClave>::getTamanio(int indice)
{	
	return ((CClaveNodo<CClave>*)this->clave[indice])->getTamanio();
	//return tamanio;
}
template<class CClave>
bool CNodo<CClave>::puedoFusionar(TIPO_DATO tamHermano,TIPO_DATO tamClave)
{
	//return  ((getTamanio() + tamHermano + tamClave)<= TAMANIO_NODO)? true:false;
	if((getTamanio() + tamHermano + tamClave)<= TAMANIO_NODO)
		return true;
	return false;
}
template<class CClave>
void CNodo<CClave>::intercambiar(CNodoBase<CClave> &nodoHrno,bool hrnoDerecho,CNodoBase<CClave> &nodoPadre,TIPO_DATO posPadre)
{
	CClave *spClaveHrno=NULL,*spClavePadre=NULL;
	TIPO_DATO cantRegistros,sucDerHrno,indice;
	spClaveHrno = new CClave;
	spClavePadre =new CClave;
	//ESTE IF ESTA MAL VER COMO DIFERENCIO SI AGARRO EL HRNO DERECHO O EL IZQUIERDO
//	

	if(hrnoDerecho)//el hrno que le va a prestar es el derecho
		indice = 0;
	else
		indice = cantRegistros = (*((CNodo<CClave>*)&nodoHrno)).getCantRegistros() -1;

	/**obtengo la clave del hermano*/
	spClaveHrno =(*((CNodo<CClave>*)&nodoHrno)).getspClave(indice);
	sucDerHrno = (*((CNodo<CClave>*)&nodoHrno)).getSucesorDer(indice);
	(*((CNodo<CClave>*)&nodoHrno)).eliminar(indice);	
	
//	cantRegistros = ((CNodoBase<CClave>*)m_rama[posRama-1])->getCantRegistros();
	(*spClavePadre) = (*((CNodo<CClave>*)&nodoPadre)).getClave(posPadre);

	//cantRegistros = ((CNodoBase<CClave>*)m_rama[posRama-0])->getCantRegistros();
	//((CNodoBase<CClave>*)m_rama[posRama-0])->setCantRegistros(cantRegistros +1);
	//pos = ((CNodoBase<CClave>*)m_rama[posRama -0])->getPosicion();		
	++this->cantRegistro; //ver si esto afecta al siguiente if
	this->setClave(*spClavePadre);	

	/*en este caso se puede dar que se quiera fucionar con un padre que en una etapa previa se quedo sin elementos
	pero tenia un hijo(por hacer una fusion) */
	
	if(!cantRegistros)
	{
		TIPO_DATO sucesorDerecho;
		if(!hrnoDerecho)
		{			
			if( this->sucesorIzq!=ULONG_MAX)
				this->setSucesorDer(this->sucesorIzq,this->posicion);
			this->setSucesorIzq(sucDerHrno);
				
		}
		else
		{
			sucesorDerecho = this->getSucesorDer(this->posicion);
			if(sucesorDerecho!=ULONG_MAX)
				this->sucesorIzq = sucesorDerecho ;
				//((CNodoBase<CClave>*)m_rama[posRama-0])->setSucesorIzq(sucesorDerecho);
			this->setSucesorDer(sucDerHrno,this->posicion);			
		}
		//((CNodoBase<CClave>*)m_rama[posRama-0])->setPosicion(pos);
	}
	
	this->ordenar();//despues de ordenar queda en la posicion=0 o al final
	//((CNodoBase<CClave>*)m_rama[posRama-0])->setPosicion(pos);
	this->mostrar();
	if(hrnoDerecho)
		spClaveHrno =(*((CNodo<CClave>*)&nodoHrno)).getspClave(indice);

	(*((CNodo<CClave>*)&nodoPadre)).setClave(*spClaveHrno,posPadre);

	//((CNodoBase<CClave>*)m_rama[posRama-0])->setSucesorDer(sucDerHrno,pos);

}
#endif /*NODO_H_*/
